package com.hermes.util.file;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;

import com.hermes.constant.ConstantParams;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

@SuppressWarnings("restriction")
public class FileUtil {	
	//delete file
	 public static boolean deleteFile(String fileName){     
	        File file = new File(fileName);     
	        if(file.isFile() && file.exists()){     
	            file.delete();     
	            System.out.println("delete single file"+fileName+"success");     
	            return true;     
	        }else{     
	            System.out.println("delete single file"+fileName+"failed");     
	            return false;     
	        }     
	    }   
	 //resize the pic
	 public static void reduceImg(String imgsrc, String imgdist, int widthdist,  
	            int heightdist) {  
	        try {  
	            File srcfile = new File(imgsrc);  
	            if (!srcfile.exists()) {  
	                return;  
	            }  
	            Image src = ImageIO.read(srcfile);  
	  
	            BufferedImage tag = new BufferedImage((int) widthdist,  
	                    (int) heightdist, BufferedImage.TYPE_INT_RGB);  
	            /* 
	             * Image.SCALE_SMOOTH 的缩略算法  生成缩略图片的平滑度的 
	             * 优先级比速度高 生成的图片质量比较好 但速度慢 
	             */  
	            tag.getGraphics().drawImage(  
	                    src.getScaledInstance(widthdist, heightdist,  
	                            Image.SCALE_SMOOTH), 0, 0, null);  
	              
	            FileOutputStream out = new FileOutputStream(imgdist);  
	            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);  
	            encoder.encode(tag);  
	            out.close();  
	  
	        } catch (IOException ex) {  
	            ex.printStackTrace();  
	        }  
	    } 
	 //make header pic
	 public static boolean makeHeader(String srcpath, String subpath, int x, int y, int width, int height) throws IOException{
		 FileInputStream is  =   null  ;  
         ImageInputStream iis  = null  ;  
        
          try {     
              // 读取图片文件   
             is  =   new  FileInputStream(srcpath);   
               
             /*  
              * 返回包含所有当前已注册 ImageReader 的 Iterator，这些 ImageReader  
              * 声称能够解码指定格式。 参数：formatName - 包含非正式格式名称 . 
              *（例如 "jpeg" 或 "tiff"）等 。  
          */   
             Iterator < ImageReader >  it  =  ImageIO.getImageReadersByFormatName("JPG");    
             ImageReader reader  =  it.next();   
              // 获取图片流    
             iis  =  ImageIO.createImageInputStream(is);  
                  
             /*   
              * <p>iis:读取源.true:只向前搜索 </p>.将它标记为 ‘只向前搜索’。 
              * 此设置意味着包含在输入源中的图像将只按顺序读取，可能允许 reader 
              *  避免缓存包含与以前已经读取的图像关联的数据的那些输入部分。 
          */   
             reader.setInput(iis, true ) ;  
               
             /*   
              * <p>描述如何对流进行解码的类<p>.用于指定如何在输入时从 Java Image I/O  
              * 框架的上下文中的流转换一幅图像或一组图像。用于特定图像格式的插件 
              * 将从其 ImageReader 实现的 getDefaultReadParam 方法中返回  
              * ImageReadParam 的实例。   
         */   
             ImageReadParam param  =  reader.getDefaultReadParam();   
                
             /*  
              * 图片裁剪区域。Rectangle 指定了坐标空间中的一个区域，通过 Rectangle 对象 
              * 的左上顶点的坐标（x，y）、宽度和高度可以定义这个区域。  
         */    
             Rectangle rect  =   new  Rectangle(x, y, width, height);   
               
                 
              // 提供一个 BufferedImage，将其用作解码像素数据的目标。    
             param.setSourceRegion(rect);   
  
             /*  
              * 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象，并将 
              * 它作为一个完整的 BufferedImage 返回。 
               */   
             BufferedImage bi  =  reader.read( 0 ,param);                  
         
              // 保存新图片    
             ImageIO.write(bi,  "JPG" ,  new  File(subpath));       
         }catch(Exception e){}  
         finally {  
              if (is != null )  
                is.close() ;         
              if (iis != null )  
                iis.close();    
         }
		 return true;
	 }
	 
	 /*
	  * get all files in path
	  * 
	  */
	 public static List<String> getFile(String path){
		 List<String> fileNames = new ArrayList<String>();
		 File file = new File(path);
		 File[] array = file.listFiles();
		 for(int i = 0;i<array.length;i++){
			 if(array[i].isFile()){
				 fileNames.add(array[i].getPath());				 
			 }else if(array[i].isDirectory()){
				 //now , do not deal dir
			 }
		 }
		 return fileNames;
	 }
	 //detale files in a folder
	 static void deleteFilesInFolder(String path){		 
		 File file = new File(path);
		 File[] array = file.listFiles();
		 for(int i = 0;i<array.length;i++){
			 if(array[i].isFile()){
				deleteFile(array[i].getPath());			 
			 }else if(array[i].isDirectory()){
				 //now , do not deal dir
			 }
		 }
	 }
	 static boolean isFolderEmpty(String path){
		 File file = new File(path);
		 if(file.list().length<1){
			 return true;
		 }
		 return false;
	}
	 // new picture produce 
	 /*
	  * 缩放图像
      * @param srcImageFile 源图像文件地址
      * @param result       缩放后的图像地址
      * @param scale        缩放比例
      * @param flag         缩放选择:true 放大; false 缩小;
	  */
	 public static void scale(String srcImageFile, String result, int scale, boolean flag)
	    {
	        try
	        {
	            BufferedImage src = ImageIO.read(new File(srcImageFile)); // 读入文件
	            int width = src.getWidth(); // 得到源图宽
	            int height = src.getHeight(); // 得到源图长
	            if (flag)
	            {
	                // 放大
	                width = width * scale;
	                height = height * scale;
	            }
	            else
	            {
	                // 缩小
	            	//  width = width / scale;
		            //   height = height / scale;
	            	//不用传入的比例参数，根据图片width产生比例
	            	float ratio = (float)ConstantParams.show_img_with/(float)width;
	                width = ConstantParams.show_img_with;
	                height = (int) (height * ratio);
	            }
	            Image image = src.getScaledInstance(width, height, Image.SCALE_DEFAULT);
	            BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
	            Graphics g = tag.getGraphics();
	            g.drawImage(image, 0, 0, null); // 绘制缩小后的图
	            g.dispose();
	            ImageIO.write(tag, "jpg", new File(result));// 输出到文件流
	        }
	        catch (IOException e)
	        {
	            e.printStackTrace();
	        }
	    }
}
